#region Using directives
using System;
using System.Globalization;
#endregion

namespace SharpWind.Math
{
	/*public class Vector3
	{
		#region Fields

		private float x;

		private float y;

		private float z;

		#endregion

		#region Constructors

		public Vector3()
		{
			this.x = 0f;
			this.y = 0f;
			this.z = 0f;
		}

		public Vector3( float value )
		{
			this.x = value;
			this.y = value;
			this.z = value;
		}

		public Vector3( float x, float y, float z )
		{
			this.x = x;
			this.y = y;
			this.z = z;
		}

		internal Vector3( Microsoft.DirectX.Vector3 vector )
		{
			this.x = vector.X;
			this.y = vector.Y;
			this.z = vector.Z;
		}

		#endregion

		#region Methods

		public static Vector3 Cross( Vector3 vector1, Vector3 vector2 )
		{
			return new Vector3
			(
				( vector1.Y * vector2.Z ) - ( vector1.Z * vector2.Y ),
				( vector1.Z * vector2.X ) - ( vector1.X * vector2.Z ),
				( vector1.X * vector2.Y ) - ( vector1.Y * vector2.X )
			);
		}

		public static float Dot( Vector3 vector1, Vector3 vector2 )
		{
			return ( vector1.X * vector2.X ) + ( vector1.Y * vector2.Y ) + ( vector1.Z * vector2.Z );
		}

		public static Vector3 Normalize( Vector3 vector )
		{
			return vector / vector.Length;
		}

		public static Vector3 Transform( Vector3 vector, Matrix matrix )
		{
			return new Vector3
			(
				( vector.X * matrix.M11 + vector.Y * matrix.M21 + vector.Z * matrix.M31 ) + matrix.M41,
				( vector.X * matrix.M12 + vector.Y * matrix.M22 + vector.Z * matrix.M32 ) + matrix.M42,
				( vector.X * matrix.M13 + vector.Y * matrix.M23 + vector.Z * matrix.M33 ) + matrix.M43
			);
		}

		public static Vector3 TransformNormal( Vector3 normal, Matrix matrix )
		{
			return new Vector3
			(
				( normal.X * matrix.M11 + normal.Y * matrix.M21 + normal.Z * matrix.M31 ),
				( normal.X * matrix.M12 + normal.Y * matrix.M22 + normal.Z * matrix.M32 ),
				( normal.X * matrix.M13 + normal.Y * matrix.M23 + normal.Z * matrix.M33 )
			);
		}

		public bool Equals( Vector3 vector )
		{
			if( ( this.x == vector.X ) && ( this.y == vector.Y ) && ( this.z == vector.Z ) )
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		public override bool Equals( object obj )
		{
			bool result = false;
			
			if( obj is Vector3 )
			{
				result = this.Equals( (Vector3)obj );
			}

			return result;
		}

		public override int GetHashCode()
		{
			return ( ( this.x.GetHashCode() + this.y.GetHashCode() ) + this.z.GetHashCode() );
		}

		public void Normalize()
		{
			float num = 1 / Length;

			this.x *= num;
			this.y *= num;
			this.z *= num;
		}

		public override string ToString()
		{
			CultureInfo provider = CultureInfo.CurrentCulture;
			
			return string.Format( provider, "{{X:{0} Y:{1} Z:{2}}}", new object[] { this.x.ToString( provider ), this.y.ToString( provider ), this.z.ToString( provider ) } );
		}

		public void Transform( Matrix matrix )
		{
			this.x = ( this.x * matrix.M11 + this.y * matrix.M21 + this.z * matrix.M31 ) + matrix.M41;
			this.y = ( this.x * matrix.M12 + this.y * matrix.M22 + this.z * matrix.M32 ) + matrix.M42;
			this.z = ( this.x * matrix.M13 + this.y * matrix.M23 + this.z * matrix.M33 ) + matrix.M43;
		}

		public void TransformNormal( Matrix matrix )
		{
			this.x = ( this.x * matrix.M11 + this.y * matrix.M21 + this.z * matrix.M31 );
			this.y = ( this.x * matrix.M12 + this.y * matrix.M22 + this.z * matrix.M32 );
			this.z = ( this.x * matrix.M13 + this.y * matrix.M23 + this.z * matrix.M33 );
		}

		#endregion

		#region Operators

		public static bool operator ==( Vector3 vector1, Vector3 vector2 )
		{
			if( ( vector1.X == vector2.X ) && ( vector1.Y == vector2.Y ) && ( vector1.Z == vector2.Z ) )
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		public static bool operator !=( Vector3 vector1, Vector3 vector2 )
		{
			if( ( vector1.X != vector2.X ) || ( vector1.Y != vector2.Y ) || ( vector1.Z != vector2.Z ) )
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		public static Vector3 operator +( Vector3 vector1, Vector3 vector2 )
		{
			return new Vector3
			(
				vector1.X + vector2.X,
				vector1.Y + vector2.Y,
				vector1.Z + vector2.Z
			);
		}

		public static Vector3 operator -( Vector3 vector1, Vector3 vector2 )
		{
			return new Vector3
			(
				vector1.X - vector2.X,
				vector1.Y - vector2.Y,
				vector1.Z - vector2.Z
			);
		}

		public static Vector3 operator -( Vector3 vector )
		{
			return new Vector3
			(
				-vector.X,
				-vector.Y,
				-vector.Z
			);
		}

		public static Vector3 operator *( Vector3 vector1, Vector3 vector2 )
		{
			return new Vector3
			(
				vector1.X * vector2.X,
				vector1.Y * vector2.Y,
				vector1.Z * vector2.Z
			);
		}

		public static Vector3 operator *( Vector3 vector, float scaleFactor )
		{
			return new Vector3
			(
				vector.X * scaleFactor,
				vector.Y * scaleFactor,
				vector.Z * scaleFactor
			);
		}

		public static Vector3 operator *( float scaleFactor, Vector3 vector )
		{
			return new Vector3
			(
				vector.X * scaleFactor,
				vector.Y * scaleFactor,
				vector.Z * scaleFactor
			);
		}

		public static Vector3 operator /( Vector3 vector1, Vector3 vector2 )
		{
			return new Vector3
			(
				vector1.X / vector2.X,
				vector1.Y / vector2.Y,
				vector1.Z / vector2.Z
			);
		}

		public static Vector3 operator /( Vector3 vector, float divider )
		{
			float num = 1f / divider;
			
			return new Vector3
			(
				vector.X * num,
				vector.Y * num,
				vector.Z * num
			);
		} 

		#endregion

		#region Properties

		public float Length
		{
			get
			{
				return MathHelper.Sqrt( Vector3.Dot( this, this ) );
			}
		}

		public float LengthSquared
		{
			get
			{
				return Vector3.Dot( this, this );
			}
		}

		public static Vector3 Zero
		{
			get
			{
				return new Vector3( 0f );
			}
		}

		public static Vector3 One 
		{
			get
			{
				return new Vector3( 1f );
			}
		}

		public static Vector3 UnitX
		{
			get
			{
				return new Vector3( 1f, 0f, 0f );
			}
		}

		public static Vector3 UnitY
		{
			get
			{
				return new Vector3( 0f, 1f, 0f );
			}
		}

		public static Vector3 UnitZ
		{
			get
			{
				return new Vector3( 0f, 0f, 1f );
			}
		}

		public static Vector3 Up
		{
			get
			{
				return new Vector3( 0f, 1f, 0f );
			}
		}

		public static Vector3 Down
		{
			get
			{
				return new Vector3( 0f, -1f, 0f );
			}
		}

		public static Vector3 Right
		{
			get
			{
				return new Vector3( 1f, 0f, 0f );
			}
		}

		public static Vector3 Left
		{
			get
			{
				return new Vector3( -1f, 0f, 0f );
			}
		}

		public static Vector3 Forward
		{
			get
			{
				return new Vector3( 0f, 0f, 1f );
			}
		}

		public static Vector3 Backward
		{
			get
			{
				return new Vector3( 0f, 0f, -1f );
			}
		}

		public float X
		{
			get
			{
				return this.x;
			}
			set
			{
				this.x = value;
			}
		}

		public float Y
		{
			get
			{
				return this.y;
			}
			set
			{
				this.y = value;
			}
		}

		public float Z 
		{
			get
			{
				return this.z;
			}
			set
			{
				this.z = value;
			}
		}

		#endregion
	}*/
}
